package br.com.eji.java;
import static org.junit.Assert.fail;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Random;

import br.com.eji.autenticacao.Autenticacao;
import br.com.eji.drivers.ChrDriver;
import br.com.eji.drivers.FoxDriver;
import br.com.eji.drivers.FoxDriverException;
import br.com.eji.drivers.IEDriver;
import br.com.eji.drivers.IEDriverException;
import br.com.eji.exceptions.TesteFalhouException;

import org.junit.Assert;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.ElementNotVisibleException;
import org.openqa.selenium.NoAlertPresentException;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.NoSuchWindowException;
import org.openqa.selenium.StaleElementReferenceException;
import org.openqa.selenium.UnhandledAlertException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebDriverException;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.remote.UnreachableBrowserException;
import org.openqa.selenium.support.ui.Select;

import cucumber.api.java.en.And;
import cucumber.api.java.en.Given;
import cucumber.api.java.en.Then;
import cucumber.api.java.en.When;

public class Generico {
		private static int cont = 0;
		//private ChrDriver driver = ChrDriver.getInstance();
		//private IEDriver driver = IEDriver.getInstance();
		private FoxDriver driver = FoxDriver.getInstance();
				
		public static String janelaMenu = null;
//--------------------------Abrir o browser-----------------------------------------------
				@Given("^entra no site com a url \"([^\"]*)\"$")
				public void entraNoSiteCom(String url) throws Throwable{
					driver.get(url); 
				}
				
				
//--------------------------autenticação e navegação no sistema---------------------------------------------
		
		@Given("^pega a instancia da janela menu$")
  		public void pegaInstanciaJanelaMenu() throws Throwable {
			if(cont == 0){
				janelaMenu = driver.getWindowHandle();	
				cont++;
				return;
			}else{
				driver.switchTo().window(janelaMenu);
				return;
			}
  		}
  		
  		@Given("^volta o foco para janela menu$")
  		public void voltaParaJanelaMenu() throws Throwable {
  			driver.switchTo().window(janelaMenu);
  		}
		
  	//Método que realiza autenticação no sistema
		@Given("^usuário entrou no sistema com login \"(.+)\" e senha \"(.+)\"$")
		public void entrarNoSistema(String login, String senha) throws Throwable {
			//caso já estiver logado.
			if(driver.isLogged == true) {
				return;
			}
	
			//driver.get("http://srv-gdis-tst01/gdisweb/login.jsf");
			//driver.get("http://srv-gdis-tst07:8180/gdisweb/pages/principal.jsf");
			//driver.get("https://homologacao-gdis");
			
			WebElement id=null, pass=null, button=null;
	
			//TODO: cadastrar um mantis para alguem colocar ide no elemento e remover esse POG.
			try {
				id = driver.findElement(By.id("form_login:login_username"));
				pass = driver.findElement(By.id("form_login:login_pwd"));
				button = driver.findElement(By.id("form_login:login_ok"));
			}  catch (Exception e) {
				//fail("Login, senha ou button não encontrado");
				id = driver.findElement(By.xpath("html/body/form/table/tbody/tr/td/input"));
				pass = driver.findElement(By.xpath("html/body/form/table/tbody/tr/td[2]/input"));
				button = driver.findElement(By.xpath("html/body/form/table/tbody/tr/td[3]/input"));
			}
	
			id.clear();
			pass.clear();
			id.sendKeys(login);
			pass.sendKeys(senha);
			button.click();
			driver.isLogged = true;
		}
  		
		//Método que realiza autenticação no sistema
		@Given("^realiza autenticação no sistema$")
		public void autenticacaoSistema() throws Throwable {
			try{
				
				//caso já estiver logado.
				if(driver.isLogged == true) {
					return;
				}
				
				//driver.get("http://srv-gdis-tst01:8080/gdisweb/login.jsf");
				driver.get("http://srv-gdis-tst07:8180/gdisweb/pages/principal.jsf");
				//driver.get("http://srv-gdis-tst08:8080/gdisweb/login.jsf");
				//driver.get("https://homologacao-gdis");
				
				//procura por elemento na tela de login
				driver.findElement(By.xpath("//*[contains(@src, '/gdisweb/templates/azul/imagens/G-dis_SubtitledTransparentBackground.png')]"));
				
				//realiza login caso estiver na tela de login
				Autenticacao aut = new Autenticacao();
				String login = aut.getLogin();
				String senha = aut.getSenha();
				//String login = "e202411";
				//String senha = "Stano2014";
				entrarNoSistema(login,senha);
				
			} catch (NoSuchElementException e) {
				//lança excessão caso não tiver na tela de login, ou seja, o usuário já está logado por meio de sessão de usuário
				System.out.println("Usuário já logado no sistema");
				driver.isLogged = true;
			}
			
		}
		
//---------------------------------manipulação de janelas e frames-----------------------------------------
		
		//EX: Ao clicar em um elemento qualquer que abre uma janela.
		//Com este método é possível mudar o foco para a janela que se abriu
		//sem a necessidade de passar o título dela. 
		//Ideal p/ janelas que tem títulos com n° de manobras, etc 
		@Given("^muda o foco para a janela que abriu$")
		public void mudaOFocoParaJanelaQueAbriu() throws Throwable {
			for(String winHandle : driver.getWindowHandles()){
			    driver.switchTo().window(winHandle);
			    System.out.println( "GET TITLE: " + driver.getTitle());
			}
			
		}
		
		//EX: And abre janela "Detalhe da Nota de Serviço"	
		@Given("^abre janela \"(.+)\"$")
		public void irParaJanela(String title) throws Throwable {
			Thread.sleep(3000);
			try{
				driver.downToWindow(title);
			}catch(NoSuchWindowException e){
				System.out.println("exception 1*************************************************");
				Thread.sleep(10000);
				driver.downToWindow(title);
			}catch(FoxDriverException e){
				System.out.println("exception 2*************************************************");
				Thread.sleep(10000);
				driver.downToWindow(title);
			}catch(UnhandledAlertException e){
				System.out.println("exception 3*************************************************");
				Thread.sleep(10000);
				driver.downToWindow(title);
			}catch(WebDriverException e){
				System.out.println("exception 4*************************************************");
				Thread.sleep(10000);
				driver.downToWindow(title);
			}
		}
		
		//Método que muda o foco para um iframe da página
		//EX: And muda o foco para iframe "FrameServicoDetalhe"	
		@And("muda o foco para iframe \"([^\"]*)\"$" )
		public void mudaOFocu(String frame){		
			driver.switchTo().frame(driver.findElement(By.id(frame)));
		}
		
		//Método que fecha a janela atual e retorna o foco para a janela anterior
		//EX: fecha janela
		@Given("^fecha janela$")
		public void fechaJanela() throws Throwable {
			try{
			driver.close();
			}catch(UnhandledAlertException e){
				
			}
		}	
		
		@When("ir para iframe")
		public void irPara() {
			try {
				driver.upToMainWindow();
				try {
					driver.downToIframe("ifGdis");
				} catch (StaleElementReferenceException e) {
					Thread.sleep(5000);
					driver.downToIframe("ifGdis");
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
//---------------------------------------verificações--------------------------------------------------------------		
		
	   // Este método verifica se existe um elemento na tela e retorna um true ou false
	   //EX:  Given verifica se existe o elemento com tag "input" e identificador "id_identificador"
	   @Given("^verifica se existe o elemento com tag \"([^\"]*)\" e identificador \"([^\"]*)\"$")
  	   public boolean verificaSeExisteElementoX(String tag, String identificador) throws Throwable {
  			boolean resp = false;
			if ( retornaElemento(tag, identificador) != null ){
				resp = true;
			}
			Assert.assertEquals(true, resp);
  			return resp; 
  		}
	// Este método verifica se NÃO existe um elemento na tela e retorna um true ou false
	   //EX:  Given verifica se não existe o elemento com tag "input" e identificador "id_identificador"
	   @Given("^verifica se não existe o elemento com tag \"([^\"]*)\" e identificador \"([^\"]*)\"$")
  	   public boolean verificaSeNãoExisteElementoX(String tag, String identificador) throws Throwable {
  			boolean resp = false;
			if ( retornaElemento(tag, identificador) != null ){
				resp = true;
			}
			Assert.assertEquals(false, resp);
  			return resp; 
  		}
		
		//Método que verifica se determinado elemento esta presente na tela
		//EX: existe campo com name = "BotaoConsultar"	
		@Then("^existe campo com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void existirCampoName(String atributo, String valor) throws Throwable {
			Thread.sleep(500);
			try {
				if (atributo.equals("id")) {
					driver.findElement(By.id(valor));
				} else if (atributo.equals("name")) {
					driver.findElement(By.name(valor));
				} else if (atributo.equals("class")) {
					driver.findElement(By.className(valor));
				}
			} catch (NoSuchElementException e) {
				System.out.println("exception*************************************************");
				Thread.sleep(10000);
				if (atributo.equals("id")) {
					driver.findElement(By.id(valor));
				} else if (atributo.equals("name")) {
					driver.findElement(By.name(valor));
				} else if (atributo.equals("class")) {
					driver.findElement(By.className(valor));
				}
			} 
		}
		
		//Método que verifica se um determinado conjunto de caracteres está presente na tela
	    //EX: verifica se na tela contém os caracteres "Filtro"
		@And("^verifica se na tela contém os caracteres \"(.+)\"$")
		public void verificaCampo(String text){
			boolean existe = driver.getPageSource().contains(text);
			Assert.assertEquals(true, existe);	
		}
		
		//Método que verifica se determinado campo está desabilitado. Se estiver retorna false
		// And verifica se campo com tag "input" e valor "id_do_campo" esta desabilitado
		@And("^verifica se campo com tag \"([^\"]*)\" e valor \"([^\"]*)\" esta desabilitado$")
		public void verificaSeDesabilitado (String tag, String valor) throws Throwable {	
			WebElement elemento = null;
			elemento = retornaElemento(tag, valor);
    		
			System.out.println( "CAMPO DESABILITADO = "+ elemento.isEnabled() );
			Assert.assertEquals(false, elemento.isEnabled());
		}
		
		//Método que verifica se determinado campo está habilitado. Se estiver retorna true.
		// And verifica se campo com tag "input" e valor "id_do_campo" esta habilitado
		@And("^verifica se campo com tag \"([^\"]*)\" e valor \"([^\"]*)\" esta habilitado$")
		public void verificaSeHabilitado (String tag, String valor) throws Throwable {	
			WebElement elemento = null;
			elemento = retornaElemento(tag, valor);
			
			System.out.println( "CAMPO HABILITADO = "+ elemento.isEnabled() );
			Assert.assertEquals(true, elemento.isEnabled());
		}

		//Verifica se tal 'xpath' tem tal 'mensagem'
		//Generico
		@Then("^Verifica se o xpath:\"([^\"]*)\" contem a mensagem:\"([^\"]*)\"$")
		public void VerificaXpathContemMensagem(String xpath, String mensagem)throws Throwable{
			try{
				String Xpath = null;
				Xpath = driver.findElement(By.xpath(xpath)).getText();
				if(!Xpath.contains(mensagem))
					throw new TesteFalhouException();
			}catch(TesteFalhouException e){
				fail("Mensagem '"+mensagem+"' não encontrada no xpath especificado");
			}
		}
		
		//Verifica se em tal 'campo' tem tal 'texto
		//Generio
		@Then("Verifica se o campo com \\s*(class|name|id)\\s*=\\s*\"(.+)\" tem o texto \"(.+)\"")
		public void VerificaCampoTemText(String atributo,String valor,String texto)throws Throwable{
			WebElement element = null;
			try{
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
				String Texto = null;
				Texto = element.getAttribute("value");
				if(!Texto.equals(texto))
					throw new TesteFalhouException();
			}catch(TesteFalhouException e){
				fail("O campo '"+valor+"' não contém a mensagem '"+texto+"' ");
			}
		}
//----------------------------------------alertas---------------------------------------------------------
	
	    //Método para verificação se mensagem do alerta contém a mensagem especificada
		//Clica no botão "Cancelar" ou algum botão que não confirma o alerta
	    //EX: o sistema exibe o alerta com a mensagem que contém "Mensagem" e não confirma alerta	
		@Then("^o sistema exibe o alerta com a mensagem que contém \"([^\"]*)\" e não confirma alerta$")
		public void exibeAlertaDismiss(String mensagem) throws Throwable {
			try{
				Alert alert = null;
				try {
					alert = driver.switchTo().alert();
				} catch(NoAlertPresentException e) {
					Thread.sleep(3000);
					alert = driver.switchTo().alert();
				}
				if (!(alert.getText().contains(mensagem)))
					throw new TesteFalhouException();
				alert.dismiss();
			} catch(TesteFalhouException e){
				fail("Mensagem do alerta não exibido conforme especificado");
			}
		}
		
		//Método para verificação se mensagem do alerta contém a mensagem especificada
		//Clica no botão "OK" ou algum botão que confirma o alerta
		//EX: And o sistema exibe o alerta com a mensagem que contém "Mensagem" e confirma alerta
		@Then("^o sistema exibe o alerta com a mensagem que contém \"([^\"]*)\" e confirma alerta$")
		public void exibeAlertaAcceptK(String mensagem) throws Throwable {
			String msg = "";
			try{
				Alert alert = null;
				try {
					alert = driver.switchTo().alert();
					 msg = alert.getText();
				} catch(NoAlertPresentException e) {
					Thread.sleep(3000);
					alert = driver.switchTo().alert();
					 msg = alert.getText();
				}
				if (!(alert.getText().contains(mensagem)))
					throw new TesteFalhouException();
				alert.accept();
			} catch(TesteFalhouException e){
				System.out.println("A MSG EXIBIDA NO ALERTA FOI: '" + msg + "'");
				fail("Mensagem do alerta não exibido conforme especificado");
			}
		}
		
		//Método para verificação se mensagem do alerta é igual a mensagem especificada
		//Clica no botão "OK" ou algum botão que confirma o alerta
		//EX: o sistema exibe o alerta com a mensagem igual a "Mensagem" e confirma alerta
		@Then("^o sistema exibe o alerta com a mensagem igual a \"([^\"]*)\" e confirma alerta$")
		public void exibeAlertaClicaOK(String mensagem) throws Throwable {
			try{
				Alert alert = null;
				try {
					alert = driver.switchTo().alert();
				} catch(NoAlertPresentException e) {
					Thread.sleep(3000);
					alert = driver.switchTo().alert();
				}
				if (!(alert.getText().equals(mensagem)))
					throw new TesteFalhouException();
				alert.accept();
			} catch(TesteFalhouException e){
				fail("Mensagem do alerta não exibido conforme especificado");
			}
		}
	

//---------------------------------------------espera esperando-------------------------------------------
		
		//Método que espera um determinado tempo para o sistema responder a solicitação
		//EX: espera "3000" milissegundos
		@When("espera \"([^\"]*)\" milissegundos")
		public void esperandoTime(String espera) {
			try {
				Long time = Long.parseLong(espera);
				Thread.sleep(time);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		//Método que espera 3 segundos para o sistema responder a solicitação
		@When("esperando")
		public void esperando() {
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		//Método que espera 10 segundos para o sistema responder a solicitação
		@When("esperando 10000")
		public void esperando10000() {
			try {
				Thread.sleep(10000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		
		//Parametros: 
		//1° uma tag, 
		//2° um identificador 
		//3° o tempo em segundos - No caso 300 segundos = 5 minutos
      //EX: Given espera carregar "a" com identificador "id_alelo" no máximo "300" segundos
		@Given ("^espera carregar \"([^\"]*)\" com identificador \"([^\"]*)\" no máximo \"([^\"]*)\" segundos$")
		public void esperaIdentificador (String tag, String identificador,String segundos) throws Throwable {
					
			Integer cont = Integer.parseInt(segundos);
			if (cont == 0){
				fail("Não carregou o elemento no tempo estimado");
			}else{
				cont--;
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				WebElement elemento =null;
				try{
				}catch (NoSuchElementException e) {
					try{
						elemento = driver.findElement(By.xpath("//"+tag+"[@name = '" + identificador + "']"));
					}catch (NoSuchElementException ex) {
						try{
							elemento = driver.findElement(By.xpath("//"+tag+"[@src = '" + identificador + "']"));
						}catch (NoSuchElementException exc) {
							try{
								elemento = driver.findElement(By.xpath("//"+tag+"[text() = '" + identificador + "']"));
							}catch (NoSuchElementException exce) {
								System.out.println( " SEGUNDOS : " + cont.toString());
								esperaIdentificador(tag, identificador, cont.toString());
							}
						}		
					}	
				}
			}
					
		}
		
//------------------------------------------------botão-------------------------------------------------------
		
		//Ex: And aciona o elemento com tag "input" e valor "cmdVoltar"
		//EX: And aciona o elemento com tag "a" e valor "Clique no link"
		@Given ("^aciona o elemento com tag \"([^\"]*)\" e valor \"([^\"]*)\"$")
		public void acionaElemento (String tag, String valor) throws Throwable {
			WebElement elemento =null;
			elemento = retornaElemento(tag, valor);
			elemento.click();	
		}
		
		//Método genérico para acionamento de botão
		//EX: And usuário acionou botão com name = "nameBotao"
		@When("^usuário acionou botão com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void acionou_botao(String atributo, String valor) throws Throwable {
			WebElement element = null;
			
			try {
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
			} catch(NoSuchElementException e) {
				System.out.println("exception*************************************************");
				Thread.sleep(10000);

				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
			}
			
			
			try {
				element.click();
			} catch (ElementNotVisibleException e) {
				//O click foi feito desse jeito porque em algumas janelas(iframe) em partes mais velhas do condis ao tentar clicar em um elemento ocorre a exceção:
				//org.openqa.selenium.ElementNotVisibleException: The point at which the driver is attempting to click on the element was not scrolled into the viewport.
				Actions builder = new Actions(driver);
				builder.moveToElement(element).click(element).perform();
			}
		}
		
		
		//Método que clica em determinado link
		//EX: clica no link "linkText"
		@Then("^clica no link \"(.+)\"$")
		public void clicaLink(String link) throws Throwable {
			try {
				driver.findElement(By.linkText(link)).click();
			} catch(NoSuchElementException e){
				fail("Link não encontrado!");
			} catch(UnreachableBrowserException e){
				Alert alert = driver.switchTo().alert();
				alert.dismiss();
			}
		}
		
		// Clica em qualquer lugar da tela.
		// Passa-se um xpath do elemente e por esse xpath o elemento será clicado
		@When("^Clica - xpath \"(.+)\"$")
		public void ClicaLink(String xpath)throws Throwable{
			try{
				driver.findElement(By.xpath(xpath)).click();
			}catch(NoSuchElementException e){
				fail("O elemento procurado não foi encontrado - xpath incorreto");
			}
		}
		
//---------------------------------------------preenche campo----------------------------------------------
		
		//Método que preenche um determinado campo com o valor especificado
		//EX: preenche campo de name = "nameCampo" com o valor "valorInserido"
		@Given("^preenche campo de \\s*(class|name|id)\\s*=\\s*\"(.+)\" com o valor \"([^\"]*)\"$")
		public void preenche_campo(String atributo, String campo, String valor) throws InterruptedException {
			WebElement element = null;
			try{
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(campo));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(campo));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(campo));
				}
				element.clear();
				element.click();
				element.sendKeys(valor);
			}
			catch(NoSuchElementException e){
				fail("Valor não inserido corretamente");
			}
		}
		
		//Método que preenche determinado campo com data ou hora atual do sistema
		//EX: informa data atual no campo de name = "nomeCampo" 
		@Then("^informa \\s*(data|hora)\\s* atual no campo de \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void informarHoraExecucao(String tempo, String atributo, String nomeCampo) throws Throwable {
			try {
				
				String txtHora = null;
				String txtData = null;
				String time = null;
				Date data = new Date();
				WebElement element = null;
				SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); 
				if (tempo.equals("data"))
					time = format.format(data).substring(0,2)+format.format(data).substring(3,5)+format.format(data).substring(6,10);
				else if (tempo.equals("hora"))
					time = format.format(data).substring(11,13)+format.format(data).substring(14,16)+format.format(data).substring(17);
				int i = 4;
				int col = 1;
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(nomeCampo));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(nomeCampo));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(nomeCampo));
				}
				element.clear();
				element.sendKeys(time);
			} catch (NoSuchElementException e) {
				fail("Erro ao preencher campos com data/hora atual");
			}
		}
		
		//EX: acrescenta "-4" "minutos" no campo de name = "nomeDoCampo"
		//EX: acrescenta "-4" "dias" no campo de id = "nomeDoCampo"
		//EX: acrescenta "4" "horas" no campo de class = "nomeDoCampo"
		@Then("^acrescenta \"([^\"]*)\" \"([^\"]*)\" no campo de \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void informaDataHora(String qtde, String tempo, String atributo, String nomeCampo) throws Throwable {
			try {
				Calendar cal = Calendar.getInstance();
				String time = null;
				Date data = null;
				WebElement element = null;
				SimpleDateFormat format = null;
				
				if(tempo.equals("minutos") || tempo.equals("minuto")){
					cal.add(Calendar.MINUTE, Integer.valueOf(qtde));
					data = cal.getTime();
					format = new SimpleDateFormat("HH:mm"); 
					time = format.format(data).substring(0,2)+format.format(data).substring(3);
				}else if(tempo.equals("dias") || tempo.equals("dia")){
					cal.add(Calendar.DAY_OF_MONTH, Integer.valueOf(qtde));
					data = cal.getTime();
					format = new SimpleDateFormat("dd/MM/yyyy"); 
					time = format.format(data).substring(0,2)+format.format(data).substring(3,5)+format.format(data).substring(6,10);
				}else if(tempo.equals("horas") || tempo.equals("hora")){
					cal.add(Calendar.HOUR_OF_DAY, Integer.valueOf(qtde));
					data = cal.getTime();
					format = new SimpleDateFormat("HH:mm"); 
					time = format.format(data).substring(0,2)+format.format(data).substring(3);
				}
				
				
				
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(nomeCampo));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(nomeCampo));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(nomeCampo));
				}
				
				element.clear();
				element.sendKeys(time);
				
				String horario = format.format(data).substring(0,2)+":"+format.format(data).substring(3);
				System.out.println("HORARIO - DATA "+horario);
			} catch (NoSuchElementException e) {
				fail("Erro ao preencher campos com hora atual");
			}
		}
		
		//Método que preenche campo de telefone 
		//EX Given preenche campo telefone com identificador "TelefoneSolicitante" e valor "2112341234" 
		//EX Given preenche campo telefone com identificador "CelularSolicitante" e valor "aleatorio"
		@Given ("^preenche campo telefone com identificador \"([^\"]*)\" e valor \"([^\"]*)\"$")
		public void preencheCampoTelefoneComValor (String identificador, String valor) throws Throwable {
			WebElement elemento =null;
			String numeroString = "";
			int numeroAleatorio = 0;
			
			elemento = retornaElemento("input", identificador);
				
			if (valor.equals("aleatorio")){
				for (int i = 0; i < 10 ;i++){
					numeroAleatorio = (int)((Math.random() * 10));
					numeroString = numeroString + numeroAleatorio;
				}	
			}else{
				numeroString = numeroString + Integer.valueOf(valor);
			}
			System.out.println("Numero Gerado : " + numeroString);
			elemento.click();
			elemento.sendKeys(numeroString);
		}
		
//------------------------------------------------combobox-----------------------------------------------
		
		//Método para seleção aleatória de um elemento de um comboBox
		//EX: Given seleciona aleatoriamente um valor no comboBox com name = "nameCombo"
		@When("^seleciona aleatoriamente um valor no comboBox com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void selecionarAleatoriamente(String atributo, String valor) throws InterruptedException{
			try{
				WebElement element = null;
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
				Select select = new Select(element);
				List<WebElement> options = select.getOptions();
				Integer pos = (int)((Math.random() * (options.size()-1))+1);
				select.selectByIndex(pos);
			} catch(NoSuchElementException e){
				Thread.sleep(3000);
				WebElement element = null;
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
				Select select = new Select(element);		
				List<WebElement> options = select.getOptions();
				Integer pos = (int)((Math.random() * (options.size()-1))+1);
				select.selectByIndex(pos);
			}
		}	
		
		
		//Método para a seleção de um elemento específico de um comboBox
		//EX: And usuário seleciona o valor "valorVisivelCombo" no comboBox com name = "nameCombo"
		@Given("^usuário seleciona o valor \"([^\"]*)\" no comboBox com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void selecionaCombo(String valor, String atributo, String text) throws Throwable {
			try{
				if (atributo.equals("id")) {
					Select select = new Select(driver.findElement(By.id(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("name")) {
					Select select = new Select(driver.findElement(By.name(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("class")) {
					Select select = new Select(driver.findElement(By.className(text)));
					select.selectByVisibleText(valor);
				}
			} catch(NoSuchElementException e){
				Thread.sleep(3000);
				if (atributo.equals("id")) {
					Select select = new Select(driver.findElement(By.id(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("name")) {
					Select select = new Select(driver.findElement(By.name(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("class")) {
					Select select = new Select(driver.findElement(By.className(text)));
					select.selectByVisibleText(valor);
				}
			} catch(StaleElementReferenceException e){
				Thread.sleep(3000);
				if (atributo.equals("id")) {
					Select select = new Select(driver.findElement(By.id(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("name")) {
					Select select = new Select(driver.findElement(By.name(text)));
					select.selectByVisibleText(valor);
				} else if (atributo.equals("class")) {
					Select select = new Select(driver.findElement(By.className(text)));
					select.selectByVisibleText(valor);
				}
			}
		}
		
		//Método que seleciona o elemento da posição especificada do comboBox
		//EX: seleciona o valor da posição "1" no comboBox com name = "nameCombo"
		@When("^seleciona o valor da posição \"([^\"]*)\" no comboBox com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void selecionarElemPos(String posicao, String atributo, String valor) throws InterruptedException{
			try{
				WebElement element = null;
				if (atributo.equals("id")) {
					element = driver.findElement(By.id(valor.trim()));
				} else if (atributo.equals("name")) {
					element = driver.findElement(By.name(valor.trim()));
				} else if (atributo.equals("class")) {
					element = driver.findElement(By.className(valor.trim()));
				}
				Select select = new Select(element);
				select.selectByIndex(Integer.valueOf(posicao));
			} catch(NoSuchElementException e){
				fail("Não foi possível selecionar o elemento!");
			}
		}
		
		//Parametros do metodo: 
		//um identificador da tag <select> (id ou name ou class) e uma opcao (numero ou a palavra "aleatorio")
		//Ex: usuario seleciona combobox com identificador "identificador_select" e opcao "aleatorio"
		@Given ("^usuario seleciona combobox com identificador \"([^\"]*)\" e opcao \"([^\"]*)\"$")
		public void selecionaComboboxComIdentificador (String identificador,String opcao) throws Throwable {
			Select combobox = null;
			List<WebElement> listaDeOpcoes = null;
			Random geradorAleatorio = new Random();
			Integer opcaoAleatoria = 0;
			
			try{
				combobox = new Select( driver.findElement(By.xpath("//select[@id = '" + identificador + "']")));
			}catch (NoSuchElementException e) {
				try{
					combobox = new Select( driver.findElement(By.xpath("//select[@name = '" + identificador + "']")));
				}catch (NoSuchElementException ex) {
					try{
						combobox = new Select( driver.findElement(By.xpath("//select[@class = '" + identificador + "']")));
					}catch (NoSuchElementException exc) {
							fail("Não encontrou o combobox");
					}		
				}	
			}
			listaDeOpcoes = combobox.getOptions();
			
			//Armazena na opcaoAleatoria um numero aleatorio de 1 ao tamanho maximo da lista
			while (opcaoAleatoria == 0){
				opcaoAleatoria = geradorAleatorio.nextInt(listaDeOpcoes.size());
			}
			if ( opcao.equals("aleatorio")){
					combobox.selectByIndex( opcaoAleatoria );
			}else{
				try {
					combobox.selectByIndex( Integer.parseInt(opcao) );
				} catch (Exception e) {
					fail("Desenvolvedor o combobox só tem " + listaDeOpcoes.size() + "opções");
				}
				
			}
			
		}
		
		//EX : usuario seleciona varios valores do combobox com id = "id_tal"	
		@And ("^usuario seleciona varios valores do combobox com \\s*(class|name|id)\\s*=\\s*\"(.+)\"$")
		public void serlecionaVariosCombobox(String atributo, String text) throws Throwable {
			List<WebElement> lista = null;
			Select oMulitpleSelection = null;
			
			try {
				
				Thread.sleep(1000);
				
				if (atributo.equals("id")) {
					 oMulitpleSelection = new Select(driver.findElement(By.id(text)));
					 lista = oMulitpleSelection.getOptions();
				} else if (atributo.equals("name")) {
					 oMulitpleSelection = new Select(driver.findElement(By.name(text)));
					 lista = oMulitpleSelection.getOptions();
				} else if (atributo.equals("class")) {
					 oMulitpleSelection = new Select(driver.findElement(By.className(text)));
					 lista = oMulitpleSelection.getOptions();
				}
				
				Random gerador = new Random();
				int tamanhoLista = 0;
			
				tamanhoLista = lista.size();
					
				if(tamanhoLista == 2){
					oMulitpleSelection.selectByIndex(0);
					oMulitpleSelection.selectByIndex(1);		
				}else if (tamanhoLista == 1){
					oMulitpleSelection.selectByIndex(0);	
				}else{
					for (int i = 0; i < tamanhoLista; i++) {
						int item = gerador.nextInt(tamanhoLista);
						oMulitpleSelection.selectByIndex(item);
					}
				}
				
			} catch (NoSuchElementException e) {
				fail("Não encontrou o elemento especificado");
			}

		}
		
		//EX: verifica se existe no comboBox com tag "select" e valor "Tipo_Serv" a opcao "RC18 - TENSAO BAIXA"	
		@And ("^verifica se existe no comboBox com tag \"([^\"]*)\" e valor \"([^\"]*)\" a opcao \"([^\"]*)\"$")
		public void verificaSeExisteNoComboboxOsCampos(String tag, String valor, String opcao){
			Select oMulitpleSelection;
			Random gerador = new Random();
			boolean resp = false;
					
				try{
					 oMulitpleSelection = new Select(driver.findElement(By.xpath("//"+tag+"[@id = '" + valor + "']")));	
				}catch (NoSuchElementException e) {
					oMulitpleSelection = new Select(driver.findElement(By.xpath("//"+tag+"[@name = '" + valor + "']")));
				}
				
				List<WebElement> listaDeOpcoes = oMulitpleSelection.getOptions();
				int tamanhoDaLista = listaDeOpcoes.size();
				
				
				for (WebElement option : listaDeOpcoes) {
					System.out.println("opcoes: " + option.getText());
					if (option.getText().equals(opcao) ){ 
						resp = true;
					}
				}
				
				Assert.assertEquals(true, resp);	
		}

		//Ex: And verifica se selecionou mais de um item no combobox com tag "select" e valor "regiao" 
		@And("^verifica se selecionou mais de um item no combobox com tag \"([^\"]*)\" e valor \"([^\"]*)\"$")
		public void verificaSeSelecionouMaisDeUmItem (String tag, String valor) throws Throwable {
			
			Select oMulitpleSelection;
			
			try{
				 oMulitpleSelection = new Select(driver.findElement(By.xpath("//"+tag+"[@id = '" + valor + "']")));	
			}catch (NoSuchElementException e) {
				oMulitpleSelection = new Select(driver.findElement(By.xpath("//"+tag+"[@name = '" + valor + "']")));
			}
			
			List<WebElement> listaDeOpcoes = oMulitpleSelection.getOptions();
			List<WebElement> listaSelecionados = oMulitpleSelection.getAllSelectedOptions();
			
			int quantidade = 0;
			
			if (listaDeOpcoes.size() > 1){
				if (listaSelecionados.size() > 1){
					quantidade = 1;
				}		
				Assert.assertEquals(1, quantidade);	
			}
				
		}


		//Método que retorna um elemento a partir de uma tag e um identificador
		//EX: retornaElemento( "input", "id_input");
		public WebElement retornaElemento (String tag, String identificador) throws Throwable {
			WebElement elemento =null;
			try{
				elemento = driver.findElement(By.xpath("//"+tag+"[@id = '" + identificador + "']"));
				return elemento;
			}catch (NoSuchElementException e) {
				try{
					elemento = driver.findElement(By.xpath("//"+tag+"[@name = '" + identificador + "']"));
					return elemento;
				}catch (NoSuchElementException ex) {
					try{
						elemento = driver.findElement(By.xpath("//"+tag+"[@class = '" + identificador + "']"));
						return elemento;
					}catch (NoSuchElementException exc) {
						try{
							elemento = driver.findElement(By.xpath("//"+tag+"[@src = '" + identificador + "']"));
							return elemento;
						}catch (NoSuchElementException exce) {
							try{
								elemento = driver.findElement(By.xpath("//"+tag+"[text() = '" + identificador + "']"));
								return elemento;
							}catch (NoSuchElementException excec) {
								try {
									elemento = driver.findElement(By.xpath("//"+tag+"[@value = '" + identificador + "']"));
									return elemento;
								} catch (NoSuchElementException excecp) {
									try {
										elemento = driver.findElement(By.xpath("//"+tag+"[@alt = '" + identificador + "']"));
										return elemento;
									} catch (NoSuchElementException excecpt) {
										try {
											elemento = driver.findElement(By.xpath("//"+tag+"[@type = '" + identificador + "']"));
											return elemento;
										} catch (Exception excecpti) {
											System.out.println( "NÃO ACIONOU O ELEMENTO COM TAG ('" + tag + "' ) E IDENTIFICADOR ( '" + identificador + "' ) ");
											return null;
										}
									}
								}	
							}
						}		
					}	
				}
			}
		}
		
		
}


